package com.ry.day1129;
import java.util.*;

public class LC73 {

      static class TreeNode {
      public int val;
      public TreeNode left, right;
      public TreeNode(int val) {
          this.val = val;
          this.left = this.right = null;
      }
  }

    /**
     * Definition of TreeNode:
     * public class TreeNode {
     *     public int val;
     *     public TreeNode left, right;
     *     public TreeNode(int val) {
     *         this.val = val;
     *         this.left = this.right = null;
     *     }
     * }
     */

    static class Solution {
        /**
         * @param preorder: A list of integers that preorder traversal of a tree
         * @param inorder: A list of integers that inorder traversal of a tree
         * @return: Root of a tree
         */
        public TreeNode buildTree(int[] preorder, int[] inorder) {
            //https://blog.csdn.net/qq_56460466/article/details/136186001
            //前序遍历的顺序是：根节点->左子树->右子树 中序遍历的顺序是：左子树->根节点->右子树
            // 所以我们可以使用前序遍历确定树及其子树的根节点，利用中序遍历与之前确定下来的根节点来确定左右子树的范围
            Map<Integer,Integer> map = new HashMap<>();
            int n = inorder.length;
            for (int i = 0; i <n ; i++) {
                map.put(inorder[i],i);
            }

            return f(preorder,0,n-1,inorder,0,n-1,map);
        }

        public TreeNode f(int[] parr,int l1,int r1,int[] inarr,int l2,int r2,Map<Integer,Integer> map){
            if(l1>r1) return null;
            if(l1 ==r1) return new TreeNode(parr[l1]);
            TreeNode root = new TreeNode(parr[l1]);
            int idx= map.get(parr[l1]);
            root.left = f(parr,l1+1,l1+idx-l2,inarr,l2,idx-1,map);
            root.right = f(parr,l1+idx-l2+1,r1,inarr,idx+1,r2,map);
            return root;
        }
    }


    public static void main(String[] args) {

    }

    /**
     * Definition of TreeNode:
     * public class TreeNode {
     *     public int val;
     *     public TreeNode left, right;
     *     public TreeNode(int val) {
     *         this.val = val;
     *         this.left = this.right = null;
     *     }
     * }
     */

    static class Solution_LC73 {
        /**
         * @param preorder: A list of integers that preorder traversal of a tree
         * @param inorder: A list of integers that inorder traversal of a tree
         * @return: Root of a tree
         */
        public TreeNode buildTree(int[] preorder, int[] inorder) {
            // write your code here
            return createTreePreIn(preorder, inorder);
        }


        public static TreeNode createTreePreIn(int[] pre,int[] in){
            if(pre == null || in==null || pre.length != in.length) return null;
            HashMap<Integer,Integer> map = new HashMap<>();
            for (int i = 0; i <in.length ; i++) {
                map.put(in[i],i);
            }

            return run1(pre,0,pre.length-1,in,0,in.length-1,map);
        }

        public static TreeNode run1(int[] arr1,int l1,int r1,int[] arr2,int l2,int r2,HashMap<Integer,Integer> map){
            if(l1 > r1) return null;
            if(l1 == r1) return new TreeNode(arr1[l1]);
            else{
                TreeNode root = new TreeNode(arr1[l1]);
                int index = map.get(arr1[l1]);

                root.left = run1(arr1,l1+1,l1+index-l2,arr2,l2,index-1,map);
                root.right = run1(arr1,l1+index-l2+1,r1,arr2,index+1,r2,map);
                return root;
            }
        }

        public TreeNode fun92(int[] pre,int[] in){
            if(pre == null || in == null || pre.length!=in.length) return null;
            int n = pre.length;
            HashMap<Integer,Integer> map = new HashMap<>();
            for (int i = 0; i < n; i++) {
                map.put(in[i],i);
            }

            return process92(pre,0,n-1,in,0,n-1,map);
        }

        public TreeNode process92(int[] pre,int l1,int r1,int[] in,int l2,int r2,HashMap<Integer,Integer> map){
            if(l1> r1) return null;
            if(l1==r1) return new TreeNode(pre[l1]);
            TreeNode node = new TreeNode(pre[l1]);
            int index = map.get(pre[l1]);
            node.left = process92(pre, l1+1, l1+index-l2, in, l2, index-1, map);
            node.right = process92(pre, l1+index-l2+1, r1, in, index+1, r2, map);

            return node;
        }




        // public TreeNode fun91(int[] pre,int[] in){
        //     if(pre == null || in==null || pre.length != in.length) return null;
        //     int n = pre.length;

        //     HashMap<Integer,Integer> map = new HashMap<>();
        //     for (int i = 0; i < n; i++) {
        //         map.put(in[i],i);
        //     }

        //     return process91(pre,0,n-1,in,0,n-1,map);
        // }

        // public TreeNode process91(int[] pre,int l1,int r1,int[] in ,int l2,int r2,HashMap<Integer,Integer> map){
        //     if(l1>r1) return null;
        //     if(l1==r1) return new TreeNode(pre[l1]);

        //     TreeNode node = new TreeNode(pre[l1]);
        //     int index = map.get(pre[l1]);

        //     node.left = process91(pre, l1+1, l1+index-l2, in, l2, index-1, map);
        //     node.right = process91(pre, l1+index-l2+1, r1, in, index+1, r2, map);
        //     return node;
        // }


        // public TreeNode fun9(int[] pre, int[] in) {
        //     if (pre == null || in == null || pre.length != in.length) return null;

        //     int n = pre.length;
        //     HashMap<Integer, Integer> map = new HashMap<>();
        //     for (int i = 0; i < n; i++) {
        //         map.put(in[i], i);
        //     }

        //     int[] pos = new int[n];
        //     return process9(pre, 0, n - 1, in, 0, n - 1, pos, 0, n - 1, map);
        // }

        // public TreeNode process9(int[] pre, int l1, int r1,
        //                          int[] in, int l2, int r2,
        //                          int[] pos, int l3, int r3, HashMap<Integer, Integer> map) {

        //     if (l1 > r1) return null;
        //     if (r1 == l1) {
        //         pos[l3] = pre[l1];
        //         new TreeNode(pre[l1]);
        //     }
        //     pos[l3] = pre[l1];
        //     int index = map.get(pre[l1]);

        //     TreeNode node = new TreeNode(pre[l1]);
        //     node.left = process9(pre, l1 + 1, l1 + index - l2, in, l2, index - 1, pos, l3, l3 + index - l2 - 1, map);
        //     node.right = process9(pre, l1 + index -l2+1, r1, in, index + 1, r2, pos, l3 + index - l2 + 1, r3 - 1, map);

        //     return node;

        // }


        //     return fun9(preorder,inorder);
        // }

        // public static TreeNode fun9(int[] pre,int[] in){
        //     if(pre ==null || in == null || pre.length != in.length) return null;

        //     HashMap<Integer,Integer> map = new HashMap<>();
        //     int n = pre.length;
        //     for (int i = 0; i <n ; i++) {
        //        map.put(in[i],i);
        //     }

        //     int[] pos = new int[n];
        //     return process9(pre,0,n-1,in,0,n-1,pos,0,n-1,map);
        // }

        // public static TreeNode process9(int[] pre,int l1,int r1,
        //                                 int[] in,int l2,int r2,
        //                                 int[] pos,int l3,int r3,HashMap<Integer,Integer> map){
        //     if(l1 > r1) return null;
        //     if(l1== r1)  return new TreeNode(pre[l1]);
        //     pos[r3] = pre[l1]; //前序遍历的第一个数是后序遍历的最后一个
        //     TreeNode node = new TreeNode(pre[l1]);
        //     int index = map.get(pre[l1]);

        //     node.left = process9(pre,l1+1,l1+index-l2,in,l2,index-1,pos,l3,l3+index-l2-1,map);
        //     node.right = process9(pre,l1+index-l2+1,r1,in,index+1,r2,pos,l3+index-l2,r3-1,map);

        //     return node;
        // }
    }



    //打印二叉树的类
    // TreeOperation.java
    static class TreeNodeShow {
    /*
    树的结构示例：
              1
            /   \
          2       3
         / \     / \
        4   5   6   7
    */

        // 用于获得树的层数
        public static int getTreeDepth(TreeNode root) {
            return root == null ? 0 : (1 + Math.max(getTreeDepth(root.left), getTreeDepth(root.right)));
        }


        private static void writeArray(TreeNode currNode, int rowIndex, int columnIndex, String[][] res, int treeDepth) {
            // 保证输入的树不为空
            if (currNode == null) return;
            // 先将当前节点保存到二维数组中
            res[rowIndex][columnIndex] = String.valueOf(currNode.val);

            // 计算当前位于树的第几层
            int currLevel = ((rowIndex + 1) / 2);
            // 若到了最后一层，则返回
            if (currLevel == treeDepth) return;
            // 计算当前行到下一行，每个元素之间的间隔（下一行的列索引与当前元素的列索引之间的间隔）
            int gap = treeDepth - currLevel - 1;

            // 对左儿子进行判断，若有左儿子，则记录相应的"/"与左儿子的值
            if (currNode.left != null) {
                res[rowIndex + 1][columnIndex - gap] = "/";
                writeArray(currNode.left, rowIndex + 2, columnIndex - gap * 2, res, treeDepth);
            }

            // 对右儿子进行判断，若有右儿子，则记录相应的"\"与右儿子的值
            if (currNode.right != null) {
                res[rowIndex + 1][columnIndex + gap] = "\\";
                writeArray(currNode.right, rowIndex + 2, columnIndex + gap * 2, res, treeDepth);
            }
        }


        public static void show(TreeNode root) {
            if (root == null) System.out.println("EMPTY!");
            // 得到树的深度
            int treeDepth = getTreeDepth(root);

            // 最后一行的宽度为2的（n - 1）次方乘3，再加1
            // 作为整个二维数组的宽度
            int arrayHeight = treeDepth * 2 - 1;
            int arrayWidth = (2 << (treeDepth - 2)) * 3 + 1;
            // 用一个字符串数组来存储每个位置应显示的元素
            String[][] res = new String[arrayHeight][arrayWidth];
            // 对数组进行初始化，默认为一个空格
            for (int i = 0; i < arrayHeight; i++) {
                for (int j = 0; j < arrayWidth; j++) {
                    res[i][j] = " ";
                }
            }

            // 从根节点开始，递归处理整个树
            // res[0][(arrayWidth + 1)/ 2] = (char)(root.val + '0');
            writeArray(root, 0, arrayWidth / 2, res, treeDepth);

            // 此时，已经将所有需要显示的元素储存到了二维数组中，将其拼接并打印即可
            for (String[] line : res) {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < line.length; i++) {
                    sb.append(line[i]);
                    if (line[i].length() > 1 && i <= line.length - 1) {
                        i += line[i].length() > 4 ? 2 : line[i].length() - 1;
                    }
                }
                System.out.println(sb.toString());
            }
        }
    }
}


/*
LintCode-Logo
搜索题目、标签、题集
中文
您上个月的个人报告已生成，点击查看
avatar
73 · 前序遍历和中序遍历树构造二叉树
算法
中等
通过率
34%

题目
题解36
笔记
讨论99+
排名
记录
描述
根据前序遍历和中序遍历树构造二叉树.

最短时间刷“透”算法面试：《66页算法宝典》.pdf

微信添加【jiuzhangfeifei】备注【66】领取


你可以假设树中不存在相同数值的节点

样例
样例 1：

输入：

前序遍历 = []
中序遍历 = []
输出：

{}
解释：

二叉树为空

样例 2：

输入：

前序遍历 = [2,1,3]
中序遍历 = [1,2,3]
输出：

{2,1,3}
解释：

二叉树如下
2
/ \
1    3

相关知识
学习《算法入门：递归》课程中的5.6前序遍历和中序遍历构造二叉树相关内容 ，了解更多相关知识！
标签
推荐课程

简历/BQ/项目 面试软技能指导
FLAG高级工程师深度BQ辅导，简历打造+1V1模拟面试，反面试套路、高效上岸！
已开启智能提示
发起考试
30 分 00 秒
12345678910111213141516171819202122
/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }

控制台
历史提交

 */
